As wireless digital communication develops and various services with high rate and strong abruptness emerge, people make much higher demands for an error correction coding technology. Low Density Parity Check (LDPC) Codes are a class of linear packet codes which can be defined by a very sparse parity check matrix or a bipartite graph. The LDPC codes were discovered by Gallager initially, so they are called Gallager codes. After decades of silence, as computer hardware and relevant theories develop, MacKay and Neal re-discover the Gallager codes and prove that the Gallager codes have properties approaching a Shannon limit. The latest research shows that the LDPC codes are characterized by being low in decoding complexity, capable of linear time coding and parallel decoding, and superior to Turbo codes under the condition of large code length, and having properties approaching the Shannon limit.
The LDPC codes are linear packet codes based on sparse parity check matrices, and low-complexity coding and decoding can be achieved using the sparseness of the parity check matrices, such that the LDPC codes tend to be practical. Irregular codes refer to LDPC codes of which parity check matrices have totally different row weights and column weights, and column weights of information bit parts of the parity check matrices are also different. Regular codes refer to LDPC codes of which parity check matrices have identical row weights and column weights. In related articles, someone calls the LDPC codes, under a second situation, in the regular codes as semi-regular codes. The frequency distribution of a basic parity check matrix is consistent with that of a parity check matrix.
The LDPC codes are special liner packet codes. In communication, every time a code word of which the packet length is N bits, M check bits are needed in order to ensure that the code word has a certain error correcting capability, and each code word is required to meet HxT=0T, where H is an M×N-dimension parity check matrix on a binary field, and xT is a 1×N sequence. All operations are carried out on a binary field GF(2). Here, addition and subtraction operations are exclusive-OR operations, and a multiplication operation is an AND operation.
The parity check matrix H of a structured LDPC code is set as an (M×z)×(N×z) matrix which is composed of M×N block matrices. Each block matrix is different powers of a z×z basic permutation matrix, and when the basic permutation matrix is a unit matrix, each block matrix is a cyclic shift matrix (right shift herein in default) of the unit matrix. Each block matrix can be uniquely identified by a power j, the power of the unit matrix can be represented by 0, and the matrix is represented by −1 generally. Thus, if each block matrix of H is replaced with a power thereof, an M×N power matrix Hb is obtained. Here, Hb is defined as a basic parity check matrix of H, H being called as a parity check matrix of Hb. During practical coding, z is equal to a value obtained by dividing a code length by a column number N of a basic parity check matrix, which is called as an expansion factor.
For instance, a matrix
  H  =      [                                                                                        1                                                  0                                                  0                                                                              0                                                  1                                                  0                                                                              0                                                  0                                                  1                                                                                          ─                                                                                                0                                                  0                                                  1                                                                              1                                                  0                                                  0                                                                              0                                                  1                                                  0                                                                        ⁢      |      ⁢                                                                                    0                                                  1                                                  0                                                                              0                                                  0                                                  1                                                                              1                                                  0                                                  0                                                                                          ─                                                                                                0                                                  1                                                  0                                                                              0                                                  0                                                  1                                                                              1                                                  0                                                  0                                                                        ⁢      |      ⁢                                                                                    1                                                  0                                                  0                                                                              0                                                  1                                                  0                                                                              0                                                  0                                                  1                                                                                          ─                                                                                                0                                                  0                                                  1                                                                              1                                                  0                                                  0                                                                              0                                                  1                                                  0                                                                        ⁢      |      ⁢                                                                                    0                                                  0                                                  0                                                                              0                                                  0                                                  0                                                                              0                                                  0                                                  0                                                                                          ─                                                                                                0                                                  1                                                  0                                                                              0                                                  0                                                  1                                                                              1                                                  0                                                  0                                                                          ]  
can be obtained by expansion using a parameter z and a 2×4 basic parity check matrix Hb, wherein
z=3, and
  Hb  =            [                                    0                                1                                0                                              -              1                                                            2                                1                                2                                1                              ]        .  
Thus, that is to say, a coder for an LDPC code is generated by a basic parity check matrix Hb, an expansion factor z and a selected basic permutation matrix. According to a definition of the above basic parity check matrix, it can be seen that the basic parity check matrix and the parity check matrix are consistent essentially under the condition that an expansion factor (an integer z greater than 1) is given.
A direct LDPC coding method refers to: dividing a code word x into N−M information bits s and M check bits c, and accordingly, dividing an M×N parity check matrix H into an M×(N−M) block corresponding to the information bits and an M×M block corresponding to the check bits respectively, that is, H=[A|B], A and B being blocks. According to H×x=0, the following formula can be obtained:
            [              A        ❘        B            ]        ⨯          [              s        c            ]        =  0
So, A×s+B×c=0 can be obtained, and c=B−1As is further derived. When the block B adopts a special matrix structure such as a strictly lower triangular matrix (semi-random matrix) and a doubly lower triangular structure, B−1 has a very simple form, a check bit part c in the code word can be directly calculated in accordance with the above formula, and it can be ensured that the coder has linear complexity.
LDPC coding can also adopt a Richarson linear time coding algorithm: a parity check matrix H has a quasi-lower triangular structure, and given that H has the following form:
  H  =      (                            A                          B                          T                                      C                          D                          E                      )  
Given that a coded code word is x=(s,p1,p2). Here, s is a system bit part of the coded code word, p1 and p2 are check bit parts of the code word, the length of p1 is g, and the length of p2 is (m−g). In the above formula, the dimensionality of A is (m−g)×(n−m), the dimensionality of B is (m−g)×g, the dimensionality of T is (m−g)×(m−g), the dimensionality of C is g×(n−m), the dimensionality of D is g×g, and the dimensionality of E is g×(m−g). All these matrices are sparse matrices, T is a lower triangular matrix, and all main diagonal elements are 1. The check bit part can be obtained by the following formulae:p1T=−φ−1(−ET−1A+C)sT p2T=−T−1(AsT+Bp1T), where φ=−ET−1B+D. 
It is crucial to search for an appropriate LDPC code parity check matrix structure. During specific implementation, a direct method or a Richarson method or other methods can be adopted for operation so as to complete coding of N bit code words from N−M bit source data. Actually, the coder achieves multiplication and addition operations for a sparse matrix in the formula using software or hardware. The multiplication operation for the sparse matrix can be composed of a plurality of z-bit (z being an expansion factor) cyclic shift registers and a plurality of z-bit adders, for LDPC codes based on unit matrices and cyclic shift matrices thereof. The addition operation for the sparse matrix is completed by the plurality of z-bit adders. The plurality of z-bit cyclic shift registers and the plurality of z-bit adders construct an LDPC coder implemented by a hardware circuit.
There are multiple LDPC decoding methods such as a probability domain BP decoding algorithm, a log domain BP decoding algorithm and a layered min-sum decoding algorithm. The probability domain BP decoding algorithm has the best performance. However, the disadvantages of the probability domain BP decoding algorithm lie in that the needed hardware cost is very high and a dynamic range of a numerical value is large and low in stability due to the fact that a great number of multiplication operations are involved and the operation quantity is large, so the probability domain BP decoding algorithm cannot be used usually in practical application. Compared with the probability domain BP decoding algorithm, the log domain BP decoding algorithm reduces lots of calculation units, but many multiplication operations are also needed, so the needed hardware cost is also high. The layered min-sum decoding algorithm transforms key calculation (log operation and multiplication operation) units of the log domain BP decoding algorithm into calculation of a minimum value and a secondary minimum value, needed hardware resources are greatly reduced, the performance will be slightly lost, and many hardware resources can be reduced. Consequently, the layered min-sum decoding algorithm is more frequently adopted in practical application.
A structured LDPC code decoder has inherent decoding parallelism, so the decoding speed is high, the throughput is high, and the decoding performance quite approaches the Shannon limit.
In various current communication modes, control signalling data will be coded with a lower bit rate so as to improve transmission reliability, or important data parts will adopt a lower bit rate coding mode to guarantee data correctness. However, various current communication systems obtain a lower bit rate implementation mode in a simple rate matching mode via higher bit rate LDPC codes. Thus, it is difficult to fully utilize coding gains, which causes poor performance of the coding and decoding system. So, an LDPC code coding method supporting a low bit rate is urgently needed now.